home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / distutils / dist.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  33KB  |  1,006 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''distutils.dist
  5.  
  6. Provides the Distribution class, which represents the module distribution
  7. being built/installed/distributed.
  8. '''
  9. __revision__ = '$Id: dist.py,v 1.72 2004/11/10 22:23:14 loewis Exp $'
  10. import sys
  11. import os
  12. import string
  13. import re
  14. from types import *
  15. from copy import copy
  16.  
  17. try:
  18.     import warnings
  19. except ImportError:
  20.     warnings = None
  21.  
  22. from distutils.errors import *
  23. from distutils.fancy_getopt import FancyGetopt, translate_longopt
  24. from distutils.util import check_environ, strtobool, rfc822_escape
  25. from distutils import log
  26. from distutils.debug import DEBUG
  27. command_re = re.compile('^[a-zA-Z]([a-zA-Z0-9_]*)$')
  28.  
  29. class Distribution:
  30.     """The core of the Distutils.  Most of the work hiding behind 'setup'
  31.     is really done within a Distribution instance, which farms the work out
  32.     to the Distutils commands specified on the command line.
  33.  
  34.     Setup scripts will almost never instantiate Distribution directly,
  35.     unless the 'setup()' function is totally inadequate to their needs.
  36.     However, it is conceivable that a setup script might wish to subclass
  37.     Distribution for some specialized purpose, and then pass the subclass
  38.     to 'setup()' as the 'distclass' keyword argument.  If so, it is
  39.     necessary to respect the expectations that 'setup' has of Distribution.
  40.     See the code for 'setup()', in core.py, for details.
  41.     """
  42.     global_options = [
  43.         ('verbose', 'v', 'run verbosely (default)', 1),
  44.         ('quiet', 'q', 'run quietly (turns verbosity off)'),
  45.         ('dry-run', 'n', "don't actually do anything"),
  46.         ('help', 'h', 'show detailed help message')]
  47.     display_options = [
  48.         ('help-commands', None, 'list all available commands'),
  49.         ('name', None, 'print package name'),
  50.         ('version', 'V', 'print package version'),
  51.         ('fullname', None, 'print <package name>-<version>'),
  52.         ('author', None, "print the author's name"),
  53.         ('author-email', None, "print the author's email address"),
  54.         ('maintainer', None, "print the maintainer's name"),
  55.         ('maintainer-email', None, "print the maintainer's email address"),
  56.         ('contact', None, "print the maintainer's name if known, else the author's"),
  57.         ('contact-email', None, "print the maintainer's email address if known, else the author's"),
  58.         ('url', None, 'print the URL for this package'),
  59.         ('license', None, 'print the license of the package'),
  60.         ('licence', None, 'alias for --license'),
  61.         ('description', None, 'print the package description'),
  62.         ('long-description', None, 'print the long package description'),
  63.         ('platforms', None, 'print the list of platforms'),
  64.         ('classifiers', None, 'print the list of classifiers'),
  65.         ('keywords', None, 'print the list of keywords')]
  66.     display_option_names = map((lambda x: translate_longopt(x[0])), display_options)
  67.     negative_opt = {
  68.         'quiet': 'verbose' }
  69.     
  70.     def __init__(self, attrs = None):
  71.         '''Construct a new Distribution instance: initialize all the
  72.         attributes of a Distribution, and then use \'attrs\' (a dictionary
  73.         mapping attribute names to values) to assign some of those
  74.         attributes their "real" values.  (Any attributes not mentioned in
  75.         \'attrs\' will be assigned to some null value: 0, None, an empty list
  76.         or dictionary, etc.)  Most importantly, initialize the
  77.         \'command_obj\' attribute to the empty dictionary; this will be
  78.         filled in with real command objects by \'parse_command_line()\'.
  79.         '''
  80.         self.verbose = 1
  81.         self.dry_run = 0
  82.         self.help = 0
  83.         for attr in self.display_option_names:
  84.             setattr(self, attr, 0)
  85.         
  86.         self.metadata = DistributionMetadata()
  87.         for basename in self.metadata._METHOD_BASENAMES:
  88.             method_name = 'get_' + basename
  89.             setattr(self, method_name, getattr(self.metadata, method_name))
  90.         
  91.         self.cmdclass = { }
  92.         self.command_packages = None
  93.         self.script_name = None
  94.         self.script_args = None
  95.         self.command_options = { }
  96.         self.packages = None
  97.         self.package_data = { }
  98.         self.package_dir = None
  99.         self.py_modules = None
  100.         self.libraries = None
  101.         self.headers = None
  102.         self.ext_modules = None
  103.         self.ext_package = None
  104.         self.include_dirs = None
  105.         self.extra_path = None
  106.         self.scripts = None
  107.         self.data_files = None
  108.         self.command_obj = { }
  109.         self.have_run = { }
  110.         if attrs:
  111.             options = attrs.get('options')
  112.             if options:
  113.                 del attrs['options']
  114.                 for command, cmd_options in options.items():
  115.                     opt_dict = self.get_option_dict(command)
  116.                     for opt, val in cmd_options.items():
  117.                         opt_dict[opt] = ('setup script', val)
  118.                     
  119.                 
  120.             
  121.             if attrs.has_key('licence'):
  122.                 attrs['license'] = attrs['licence']
  123.                 del attrs['licence']
  124.                 msg = "'licence' distribution option is deprecated; use 'license'"
  125.                 if warnings is not None:
  126.                     warnings.warn(msg)
  127.                 else:
  128.                     sys.stderr.write(msg + '\n')
  129.             
  130.             for key, val in attrs.items():
  131.                 if hasattr(self.metadata, key):
  132.                     setattr(self.metadata, key, val)
  133.                     continue
  134.                 if hasattr(self, key):
  135.                     setattr(self, key, val)
  136.                     continue
  137.                 msg = 'Unknown distribution option: %s' % repr(key)
  138.                 if warnings is not None:
  139.                     warnings.warn(msg)
  140.                     continue
  141.                 sys.stderr.write(msg + '\n')
  142.             
  143.         
  144.         self.finalize_options()
  145.  
  146.     
  147.     def get_option_dict(self, command):
  148.         """Get the option dictionary for a given command.  If that
  149.         command's option dictionary hasn't been created yet, then create it
  150.         and return the new dictionary; otherwise, return the existing
  151.         option dictionary.
  152.         """
  153.         dict = self.command_options.get(command)
  154.         if dict is None:
  155.             dict = self.command_options[command] = { }
  156.         
  157.         return dict
  158.  
  159.     
  160.     def dump_option_dicts(self, header = None, commands = None, indent = ''):
  161.         pformat = pformat
  162.         import pprint
  163.         if commands is None:
  164.             commands = self.command_options.keys()
  165.             commands.sort()
  166.         
  167.         if header is not None:
  168.             print indent + header
  169.             indent = indent + '  '
  170.         
  171.         if not commands:
  172.             print indent + 'no commands known yet'
  173.             return None
  174.         
  175.         for cmd_name in commands:
  176.             opt_dict = self.command_options.get(cmd_name)
  177.             if opt_dict is None:
  178.                 print indent + "no option dict for '%s' command" % cmd_name
  179.                 continue
  180.             print indent + "option dict for '%s' command:" % cmd_name
  181.             out = pformat(opt_dict)
  182.             for line in string.split(out, '\n'):
  183.                 print indent + '  ' + line
  184.             
  185.         
  186.  
  187.     
  188.     def find_config_files(self):
  189.         """Find as many configuration files as should be processed for this
  190.         platform, and return a list of filenames in the order in which they
  191.         should be parsed.  The filenames returned are guaranteed to exist
  192.         (modulo nasty race conditions).
  193.  
  194.         There are three possible config files: distutils.cfg in the
  195.         Distutils installation directory (ie. where the top-level
  196.         Distutils __inst__.py file lives), a file in the user's home
  197.         directory named .pydistutils.cfg on Unix and pydistutils.cfg
  198.         on Windows/Mac, and setup.cfg in the current directory.
  199.         """
  200.         files = []
  201.         check_environ()
  202.         sys_dir = os.path.dirname(sys.modules['distutils'].__file__)
  203.         sys_file = os.path.join(sys_dir, 'distutils.cfg')
  204.         if os.path.isfile(sys_file):
  205.             files.append(sys_file)
  206.         
  207.         if os.name == 'posix':
  208.             user_filename = '.pydistutils.cfg'
  209.         else:
  210.             user_filename = 'pydistutils.cfg'
  211.         if os.environ.has_key('HOME'):
  212.             user_file = os.path.join(os.environ.get('HOME'), user_filename)
  213.             if os.path.isfile(user_file):
  214.                 files.append(user_file)
  215.             
  216.         
  217.         local_file = 'setup.cfg'
  218.         if os.path.isfile(local_file):
  219.             files.append(local_file)
  220.         
  221.         return files
  222.  
  223.     
  224.     def parse_config_files(self, filenames = None):
  225.         ConfigParser = ConfigParser
  226.         import ConfigParser
  227.         if filenames is None:
  228.             filenames = self.find_config_files()
  229.         
  230.         if DEBUG:
  231.             print 'Distribution.parse_config_files():'
  232.         
  233.         parser = ConfigParser()
  234.         for filename in filenames:
  235.             if DEBUG:
  236.                 print '  reading', filename
  237.             
  238.             parser.read(filename)
  239.             for section in parser.sections():
  240.                 options = parser.options(section)
  241.                 opt_dict = self.get_option_dict(section)
  242.                 for opt in options:
  243.                     if opt != '__name__':
  244.                         val = parser.get(section, opt)
  245.                         opt = string.replace(opt, '-', '_')
  246.                         opt_dict[opt] = (filename, val)
  247.                         continue
  248.                 
  249.             
  250.             parser.__init__()
  251.         
  252.  
  253.     
  254.     def parse_command_line(self):
  255.         '''Parse the setup script\'s command line, taken from the
  256.         \'script_args\' instance attribute (which defaults to \'sys.argv[1:]\'
  257.         -- see \'setup()\' in core.py).  This list is first processed for
  258.         "global options" -- options that set attributes of the Distribution
  259.         instance.  Then, it is alternately scanned for Distutils commands
  260.         and options for that command.  Each new command terminates the
  261.         options for the previous command.  The allowed options for a
  262.         command are determined by the \'user_options\' attribute of the
  263.         command class -- thus, we have to be able to load command classes
  264.         in order to parse the command line.  Any error in that \'options\'
  265.         attribute raises DistutilsGetoptError; any error on the
  266.         command-line raises DistutilsArgError.  If no Distutils commands
  267.         were found on the command line, raises DistutilsArgError.  Return
  268.         true if command-line was successfully parsed and we should carry
  269.         on with executing commands; false if no errors but we shouldn\'t
  270.         execute commands (currently, this only happens if user asks for
  271.         help).
  272.         '''
  273.         toplevel_options = self._get_toplevel_options()
  274.         if sys.platform == 'mac':
  275.             import EasyDialogs as EasyDialogs
  276.             cmdlist = self.get_command_list()
  277.             self.script_args = EasyDialogs.GetArgv(toplevel_options + self.display_options, cmdlist)
  278.         
  279.         self.commands = []
  280.         parser = FancyGetopt(toplevel_options + self.display_options)
  281.         parser.set_negative_aliases(self.negative_opt)
  282.         parser.set_aliases({
  283.             'licence': 'license' })
  284.         args = parser.getopt(args = self.script_args, object = self)
  285.         option_order = parser.get_option_order()
  286.         log.set_verbosity(self.verbose)
  287.         if self.handle_display_options(option_order):
  288.             return None
  289.         
  290.         while args:
  291.             args = self._parse_command_opts(parser, args)
  292.             if args is None:
  293.                 return None
  294.                 continue
  295.         if self.help:
  296.             self._show_help(parser, display_options = len(self.commands) == 0, commands = self.commands)
  297.             return None
  298.         
  299.         if not self.commands:
  300.             raise DistutilsArgError, 'no commands supplied'
  301.         
  302.         return 1
  303.  
  304.     
  305.     def _get_toplevel_options(self):
  306.         '''Return the non-display options recognized at the top level.
  307.  
  308.         This includes options that are recognized *only* at the top
  309.         level as well as options recognized for commands.
  310.         '''
  311.         return self.global_options + [
  312.             ('command-packages=', None, 'list of packages that provide distutils commands')]
  313.  
  314.     
  315.     def _parse_command_opts(self, parser, args):
  316.         """Parse the command-line options for a single command.
  317.         'parser' must be a FancyGetopt instance; 'args' must be the list
  318.         of arguments, starting with the current command (whose options
  319.         we are about to parse).  Returns a new version of 'args' with
  320.         the next command at the front of the list; will be the empty
  321.         list if there are no more commands on the command line.  Returns
  322.         None if the user asked for help on this command.
  323.         """
  324.         Command = Command
  325.         import distutils.cmd
  326.         command = args[0]
  327.         if not command_re.match(command):
  328.             raise SystemExit, "invalid command name '%s'" % command
  329.         
  330.         self.commands.append(command)
  331.         
  332.         try:
  333.             cmd_class = self.get_command_class(command)
  334.         except DistutilsModuleError:
  335.             msg = None
  336.             raise DistutilsArgError, msg
  337.  
  338.         if not issubclass(cmd_class, Command):
  339.             raise DistutilsClassError, 'command class %s must subclass Command' % cmd_class
  340.         
  341.         if not hasattr(cmd_class, 'user_options') and type(cmd_class.user_options) is ListType:
  342.             raise DistutilsClassError, ('command class %s must provide ' + "'user_options' attribute (a list of tuples)") % cmd_class
  343.         
  344.         negative_opt = self.negative_opt
  345.         if hasattr(cmd_class, 'negative_opt'):
  346.             negative_opt = copy(negative_opt)
  347.             negative_opt.update(cmd_class.negative_opt)
  348.         
  349.         if hasattr(cmd_class, 'help_options') and type(cmd_class.help_options) is ListType:
  350.             help_options = fix_help_options(cmd_class.help_options)
  351.         else:
  352.             help_options = []
  353.         parser.set_option_table(self.global_options + cmd_class.user_options + help_options)
  354.         parser.set_negative_aliases(negative_opt)
  355.         (args, opts) = parser.getopt(args[1:])
  356.         if hasattr(opts, 'help') and opts.help:
  357.             self._show_help(parser, display_options = 0, commands = [
  358.                 cmd_class])
  359.             return None
  360.         
  361.         if hasattr(cmd_class, 'help_options') and type(cmd_class.help_options) is ListType:
  362.             help_option_found = 0
  363.             for help_option, short, desc, func in cmd_class.help_options:
  364.                 if hasattr(opts, parser.get_attr_name(help_option)):
  365.                     help_option_found = 1
  366.                     if callable(func):
  367.                         func()
  368.                     else:
  369.                         raise DistutilsClassError("invalid help function %r for help option '%s': must be a callable object (function, etc.)" % (func, help_option))
  370.                 callable(func)
  371.             
  372.             if help_option_found:
  373.                 return None
  374.             
  375.         
  376.         opt_dict = self.get_option_dict(command)
  377.         for name, value in vars(opts).items():
  378.             opt_dict[name] = ('command line', value)
  379.         
  380.         return args
  381.  
  382.     
  383.     def finalize_options(self):
  384.         '''Set final values for all the options on the Distribution
  385.         instance, analogous to the .finalize_options() method of Command
  386.         objects.
  387.         '''
  388.         keywords = self.metadata.keywords
  389.         if keywords is not None:
  390.             if type(keywords) is StringType:
  391.                 keywordlist = string.split(keywords, ',')
  392.                 self.metadata.keywords = map(string.strip, keywordlist)
  393.             
  394.         
  395.         platforms = self.metadata.platforms
  396.         if platforms is not None:
  397.             if type(platforms) is StringType:
  398.                 platformlist = string.split(platforms, ',')
  399.                 self.metadata.platforms = map(string.strip, platformlist)
  400.             
  401.         
  402.  
  403.     
  404.     def _show_help(self, parser, global_options = 1, display_options = 1, commands = []):
  405.         '''Show help for the setup script command-line in the form of
  406.         several lists of command-line options.  \'parser\' should be a
  407.         FancyGetopt instance; do not expect it to be returned in the
  408.         same state, as its option table will be reset to make it
  409.         generate the correct help text.
  410.  
  411.         If \'global_options\' is true, lists the global options:
  412.         --verbose, --dry-run, etc.  If \'display_options\' is true, lists
  413.         the "display-only" options: --name, --version, etc.  Finally,
  414.         lists per-command help for every command name or command class
  415.         in \'commands\'.
  416.         '''
  417.         gen_usage = gen_usage
  418.         import distutils.core
  419.         Command = Command
  420.         import distutils.cmd
  421.         if global_options:
  422.             if display_options:
  423.                 options = self._get_toplevel_options()
  424.             else:
  425.                 options = self.global_options
  426.             parser.set_option_table(options)
  427.             parser.print_help('Global options:')
  428.             print 
  429.         
  430.         if display_options:
  431.             parser.set_option_table(self.display_options)
  432.             parser.print_help('Information display options (just display ' + 'information, ignore any commands)')
  433.             print 
  434.         
  435.         for command in self.commands:
  436.             if type(command) is ClassType and issubclass(command, Command):
  437.                 klass = command
  438.             else:
  439.                 klass = self.get_command_class(command)
  440.             if hasattr(klass, 'help_options') and type(klass.help_options) is ListType:
  441.                 parser.set_option_table(klass.user_options + fix_help_options(klass.help_options))
  442.             else:
  443.                 parser.set_option_table(klass.user_options)
  444.             parser.print_help("Options for '%s' command:" % klass.__name__)
  445.             print 
  446.         
  447.         print gen_usage(self.script_name)
  448.  
  449.     
  450.     def handle_display_options(self, option_order):
  451.         '''If there were any non-global "display-only" options
  452.         (--help-commands or the metadata display options) on the command
  453.         line, display the requested info and return true; else return
  454.         false.
  455.         '''
  456.         gen_usage = gen_usage
  457.         import distutils.core
  458.         if self.help_commands:
  459.             self.print_commands()
  460.             print 
  461.             print gen_usage(self.script_name)
  462.             return 1
  463.         
  464.         any_display_options = 0
  465.         is_display_option = { }
  466.         for option in self.display_options:
  467.             is_display_option[option[0]] = 1
  468.         
  469.         for opt, val in option_order:
  470.             if val and is_display_option.get(opt):
  471.                 opt = translate_longopt(opt)
  472.                 value = getattr(self.metadata, 'get_' + opt)()
  473.                 if opt in [
  474.                     'keywords',
  475.                     'platforms']:
  476.                     print string.join(value, ',')
  477.                 elif opt == 'classifiers':
  478.                     print string.join(value, '\n')
  479.                 else:
  480.                     print value
  481.                 any_display_options = 1
  482.                 continue
  483.         
  484.         return any_display_options
  485.  
  486.     
  487.     def print_command_list(self, commands, header, max_length):
  488.         """Print a subset of the list of all commands -- used by
  489.         'print_commands()'.
  490.         """
  491.         print header + ':'
  492.         for cmd in commands:
  493.             klass = self.cmdclass.get(cmd)
  494.             if not klass:
  495.                 klass = self.get_command_class(cmd)
  496.             
  497.             
  498.             try:
  499.                 description = klass.description
  500.             except AttributeError:
  501.                 description = '(no description available)'
  502.  
  503.             print '  %-*s  %s' % (max_length, cmd, description)
  504.         
  505.  
  506.     
  507.     def print_commands(self):
  508.         '''Print out a help message listing all available commands with a
  509.         description of each.  The list is divided into "standard commands"
  510.         (listed in distutils.command.__all__) and "extra commands"
  511.         (mentioned in self.cmdclass, but not a standard command).  The
  512.         descriptions come from the command class attribute
  513.         \'description\'.
  514.         '''
  515.         import distutils.command as distutils
  516.         std_commands = distutils.command.__all__
  517.         is_std = { }
  518.         for cmd in std_commands:
  519.             is_std[cmd] = 1
  520.         
  521.         extra_commands = []
  522.         for cmd in self.cmdclass.keys():
  523.             if not is_std.get(cmd):
  524.                 extra_commands.append(cmd)
  525.                 continue
  526.         
  527.         max_length = 0
  528.         for cmd in std_commands + extra_commands:
  529.             if len(cmd) > max_length:
  530.                 max_length = len(cmd)
  531.                 continue
  532.         
  533.         self.print_command_list(std_commands, 'Standard commands', max_length)
  534.         if extra_commands:
  535.             print 
  536.             self.print_command_list(extra_commands, 'Extra commands', max_length)
  537.         
  538.  
  539.     
  540.     def get_command_list(self):
  541.         '''Get a list of (command, description) tuples.
  542.         The list is divided into "standard commands" (listed in
  543.         distutils.command.__all__) and "extra commands" (mentioned in
  544.         self.cmdclass, but not a standard command).  The descriptions come
  545.         from the command class attribute \'description\'.
  546.         '''
  547.         import distutils.command as distutils
  548.         std_commands = distutils.command.__all__
  549.         is_std = { }
  550.         for cmd in std_commands:
  551.             is_std[cmd] = 1
  552.         
  553.         extra_commands = []
  554.         for cmd in self.cmdclass.keys():
  555.             if not is_std.get(cmd):
  556.                 extra_commands.append(cmd)
  557.                 continue
  558.         
  559.         rv = []
  560.         for cmd in std_commands + extra_commands:
  561.             klass = self.cmdclass.get(cmd)
  562.             if not klass:
  563.                 klass = self.get_command_class(cmd)
  564.             
  565.             
  566.             try:
  567.                 description = klass.description
  568.             except AttributeError:
  569.                 description = '(no description available)'
  570.  
  571.             rv.append((cmd, description))
  572.         
  573.         return rv
  574.  
  575.     
  576.     def get_command_packages(self):
  577.         '''Return a list of packages from which commands are loaded.'''
  578.         pkgs = self.command_packages
  579.         if not isinstance(pkgs, type([])):
  580.             if not pkgs:
  581.                 pass
  582.             pkgs = string.split('', ',')
  583.             for i in range(len(pkgs)):
  584.                 pkgs[i] = string.strip(pkgs[i])
  585.             
  586.             pkgs = filter(None, pkgs)
  587.             if 'distutils.command' not in pkgs:
  588.                 pkgs.insert(0, 'distutils.command')
  589.             
  590.             self.command_packages = pkgs
  591.         
  592.         return pkgs
  593.  
  594.     
  595.     def get_command_class(self, command):
  596.         '''Return the class that implements the Distutils command named by
  597.         \'command\'.  First we check the \'cmdclass\' dictionary; if the
  598.         command is mentioned there, we fetch the class object from the
  599.         dictionary and return it.  Otherwise we load the command module
  600.         ("distutils.command." + command) and fetch the command class from
  601.         the module.  The loaded class is also stored in \'cmdclass\'
  602.         to speed future calls to \'get_command_class()\'.
  603.  
  604.         Raises DistutilsModuleError if the expected module could not be
  605.         found, or if that module does not define the expected class.
  606.         '''
  607.         klass = self.cmdclass.get(command)
  608.         if klass:
  609.             return klass
  610.         
  611.         for pkgname in self.get_command_packages():
  612.             module_name = '%s.%s' % (pkgname, command)
  613.             klass_name = command
  614.             
  615.             try:
  616.                 __import__(module_name)
  617.                 module = sys.modules[module_name]
  618.             except ImportError:
  619.                 continue
  620.  
  621.             
  622.             try:
  623.                 klass = getattr(module, klass_name)
  624.             except AttributeError:
  625.                 raise DistutilsModuleError, "invalid command '%s' (no class '%s' in module '%s')" % (command, klass_name, module_name)
  626.  
  627.             self.cmdclass[command] = klass
  628.             return klass
  629.         
  630.         raise DistutilsModuleError("invalid command '%s'" % command)
  631.  
  632.     
  633.     def get_command_obj(self, command, create = 1):
  634.         """Return the command object for 'command'.  Normally this object
  635.         is cached on a previous call to 'get_command_obj()'; if no command
  636.         object for 'command' is in the cache, then we either create and
  637.         return it (if 'create' is true) or return None.
  638.         """
  639.         cmd_obj = self.command_obj.get(command)
  640.         if not cmd_obj and create:
  641.             if DEBUG:
  642.                 print "Distribution.get_command_obj(): creating '%s' command object" % command
  643.             
  644.             klass = self.get_command_class(command)
  645.             cmd_obj = self.command_obj[command] = klass(self)
  646.             self.have_run[command] = 0
  647.             options = self.command_options.get(command)
  648.             if options:
  649.                 self._set_command_options(cmd_obj, options)
  650.             
  651.         
  652.         return cmd_obj
  653.  
  654.     
  655.     def _set_command_options(self, command_obj, option_dict = None):
  656.         """Set the options for 'command_obj' from 'option_dict'.  Basically
  657.         this means copying elements of a dictionary ('option_dict') to
  658.         attributes of an instance ('command').
  659.  
  660.         'command_obj' must be a Command instance.  If 'option_dict' is not
  661.         supplied, uses the standard option dictionary for this command
  662.         (from 'self.command_options').
  663.         """
  664.         command_name = command_obj.get_command_name()
  665.         if option_dict is None:
  666.             option_dict = self.get_option_dict(command_name)
  667.         
  668.         if DEBUG:
  669.             print "  setting options for '%s' command:" % command_name
  670.         
  671.         for source, value in option_dict.items():
  672.             
  673.             try:
  674.                 bool_opts = map(translate_longopt, command_obj.boolean_options)
  675.             except AttributeError:
  676.                 None if DEBUG else None
  677.                 None if DEBUG else None
  678.                 bool_opts = []
  679.             except:
  680.                 None if DEBUG else None
  681.  
  682.             
  683.             try:
  684.                 neg_opt = command_obj.negative_opt
  685.             except AttributeError:
  686.                 None if DEBUG else None
  687.                 None if DEBUG else None
  688.                 neg_opt = { }
  689.             except:
  690.                 None if DEBUG else None
  691.  
  692.             
  693.             try:
  694.                 is_string = type(value) is StringType
  695.                 if neg_opt.has_key(option) and is_string:
  696.                     setattr(command_obj, neg_opt[option], not strtobool(value))
  697.                 elif option in bool_opts and is_string:
  698.                     setattr(command_obj, option, strtobool(value))
  699.                 elif hasattr(command_obj, option):
  700.                     setattr(command_obj, option, value)
  701.                 else:
  702.                     raise DistutilsOptionError, "error in %s: command '%s' has no such option '%s'" % (source, command_name, option)
  703.             continue
  704.             except ValueError:
  705.                 None if DEBUG else None
  706.                 msg = None if DEBUG else None
  707.                 raise DistutilsOptionError, msg
  708.                 continue
  709.             
  710.  
  711.         
  712.  
  713.     
  714.     def reinitialize_command(self, command, reinit_subcommands = 0):
  715.         '''Reinitializes a command to the state it was in when first
  716.         returned by \'get_command_obj()\': ie., initialized but not yet
  717.         finalized.  This provides the opportunity to sneak option
  718.         values in programmatically, overriding or supplementing
  719.         user-supplied values from the config files and command line.
  720.         You\'ll have to re-finalize the command object (by calling
  721.         \'finalize_options()\' or \'ensure_finalized()\') before using it for
  722.         real.
  723.  
  724.         \'command\' should be a command name (string) or command object.  If
  725.         \'reinit_subcommands\' is true, also reinitializes the command\'s
  726.         sub-commands, as declared by the \'sub_commands\' class attribute (if
  727.         it has one).  See the "install" command for an example.  Only
  728.         reinitializes the sub-commands that actually matter, ie. those
  729.         whose test predicates return true.
  730.  
  731.         Returns the reinitialized command object.
  732.         '''
  733.         Command = Command
  734.         import distutils.cmd
  735.         if not isinstance(command, Command):
  736.             command_name = command
  737.             command = self.get_command_obj(command_name)
  738.         else:
  739.             command_name = command.get_command_name()
  740.         if not command.finalized:
  741.             return command
  742.         
  743.         command.initialize_options()
  744.         command.finalized = 0
  745.         self.have_run[command_name] = 0
  746.         self._set_command_options(command)
  747.         if reinit_subcommands:
  748.             for sub in command.get_sub_commands():
  749.                 self.reinitialize_command(sub, reinit_subcommands)
  750.             
  751.         
  752.         return command
  753.  
  754.     
  755.     def announce(self, msg, level = 1):
  756.         log.debug(msg)
  757.  
  758.     
  759.     def run_commands(self):
  760.         """Run each command that was seen on the setup script command line.
  761.         Uses the list of commands found and cache of command objects
  762.         created by 'get_command_obj()'.
  763.         """
  764.         for cmd in self.commands:
  765.             self.run_command(cmd)
  766.         
  767.  
  768.     
  769.     def run_command(self, command):
  770.         """Do whatever it takes to run a command (including nothing at all,
  771.         if the command has already been run).  Specifically: if we have
  772.         already created and run the command named by 'command', return
  773.         silently without doing anything.  If the command named by 'command'
  774.         doesn't even have a command object yet, create one.  Then invoke
  775.         'run()' on that command object (or an existing one).
  776.         """
  777.         if self.have_run.get(command):
  778.             return None
  779.         
  780.         log.info('running %s', command)
  781.         cmd_obj = self.get_command_obj(command)
  782.         cmd_obj.ensure_finalized()
  783.         cmd_obj.run()
  784.         self.have_run[command] = 1
  785.  
  786.     
  787.     def has_pure_modules(self):
  788.         if not self.packages and self.py_modules:
  789.             pass
  790.         return len([]) > 0
  791.  
  792.     
  793.     def has_ext_modules(self):
  794.         if self.ext_modules:
  795.             pass
  796.         return len(self.ext_modules) > 0
  797.  
  798.     
  799.     def has_c_libraries(self):
  800.         if self.libraries:
  801.             pass
  802.         return len(self.libraries) > 0
  803.  
  804.     
  805.     def has_modules(self):
  806.         if not self.has_pure_modules():
  807.             pass
  808.         return self.has_ext_modules()
  809.  
  810.     
  811.     def has_headers(self):
  812.         if self.headers:
  813.             pass
  814.         return len(self.headers) > 0
  815.  
  816.     
  817.     def has_scripts(self):
  818.         if self.scripts:
  819.             pass
  820.         return len(self.scripts) > 0
  821.  
  822.     
  823.     def has_data_files(self):
  824.         if self.data_files:
  825.             pass
  826.         return len(self.data_files) > 0
  827.  
  828.     
  829.     def is_pure(self):
  830.         if self.has_pure_modules() and not self.has_ext_modules():
  831.             pass
  832.         return not self.has_c_libraries()
  833.  
  834.  
  835.  
  836. class DistributionMetadata:
  837.     '''Dummy class to hold the distribution meta-data: name, version,
  838.     author, and so forth.
  839.     '''
  840.     _METHOD_BASENAMES = ('name', 'version', 'author', 'author_email', 'maintainer', 'maintainer_email', 'url', 'license', 'description', 'long_description', 'keywords', 'platforms', 'fullname', 'contact', 'contact_email', 'license', 'classifiers', 'download_url')
  841.     
  842.     def __init__(self):
  843.         self.name = None
  844.         self.version = None
  845.         self.author = None
  846.         self.author_email = None
  847.         self.maintainer = None
  848.         self.maintainer_email = None
  849.         self.url = None
  850.         self.license = None
  851.         self.description = None
  852.         self.long_description = None
  853.         self.keywords = None
  854.         self.platforms = None
  855.         self.classifiers = None
  856.         self.download_url = None
  857.  
  858.     
  859.     def write_pkg_info(self, base_dir):
  860.         '''Write the PKG-INFO file into the release tree.
  861.         '''
  862.         pkg_info = open(os.path.join(base_dir, 'PKG-INFO'), 'w')
  863.         pkg_info.write('Metadata-Version: 1.0\n')
  864.         pkg_info.write('Name: %s\n' % self.get_name())
  865.         pkg_info.write('Version: %s\n' % self.get_version())
  866.         pkg_info.write('Summary: %s\n' % self.get_description())
  867.         pkg_info.write('Home-page: %s\n' % self.get_url())
  868.         pkg_info.write('Author: %s\n' % self.get_contact())
  869.         pkg_info.write('Author-email: %s\n' % self.get_contact_email())
  870.         pkg_info.write('License: %s\n' % self.get_license())
  871.         if self.download_url:
  872.             pkg_info.write('Download-URL: %s\n' % self.download_url)
  873.         
  874.         long_desc = rfc822_escape(self.get_long_description())
  875.         pkg_info.write('Description: %s\n' % long_desc)
  876.         keywords = string.join(self.get_keywords(), ',')
  877.         if keywords:
  878.             pkg_info.write('Keywords: %s\n' % keywords)
  879.         
  880.         for platform in self.get_platforms():
  881.             pkg_info.write('Platform: %s\n' % platform)
  882.         
  883.         for classifier in self.get_classifiers():
  884.             pkg_info.write('Classifier: %s\n' % classifier)
  885.         
  886.         pkg_info.close()
  887.  
  888.     
  889.     def get_name(self):
  890.         if not self.name:
  891.             pass
  892.         return 'UNKNOWN'
  893.  
  894.     
  895.     def get_version(self):
  896.         if not self.version:
  897.             pass
  898.         return '0.0.0'
  899.  
  900.     
  901.     def get_fullname(self):
  902.         return '%s-%s' % (self.get_name(), self.get_version())
  903.  
  904.     
  905.     def get_author(self):
  906.         if not self.author:
  907.             pass
  908.         return 'UNKNOWN'
  909.  
  910.     
  911.     def get_author_email(self):
  912.         if not self.author_email:
  913.             pass
  914.         return 'UNKNOWN'
  915.  
  916.     
  917.     def get_maintainer(self):
  918.         if not self.maintainer:
  919.             pass
  920.         return 'UNKNOWN'
  921.  
  922.     
  923.     def get_maintainer_email(self):
  924.         if not self.maintainer_email:
  925.             pass
  926.         return 'UNKNOWN'
  927.  
  928.     
  929.     def get_contact(self):
  930.         if not self.maintainer and self.author:
  931.             pass
  932.         return 'UNKNOWN'
  933.  
  934.     
  935.     def get_contact_email(self):
  936.         if not self.maintainer_email and self.author_email:
  937.             pass
  938.         return 'UNKNOWN'
  939.  
  940.     
  941.     def get_url(self):
  942.         if not self.url:
  943.             pass
  944.         return 'UNKNOWN'
  945.  
  946.     
  947.     def get_license(self):
  948.         if not self.license:
  949.             pass
  950.         return 'UNKNOWN'
  951.  
  952.     get_licence = get_license
  953.     
  954.     def get_description(self):
  955.         if not self.description:
  956.             pass
  957.         return 'UNKNOWN'
  958.  
  959.     
  960.     def get_long_description(self):
  961.         if not self.long_description:
  962.             pass
  963.         return 'UNKNOWN'
  964.  
  965.     
  966.     def get_keywords(self):
  967.         if not self.keywords:
  968.             pass
  969.         return []
  970.  
  971.     
  972.     def get_platforms(self):
  973.         if not self.platforms:
  974.             pass
  975.         return [
  976.             'UNKNOWN']
  977.  
  978.     
  979.     def get_classifiers(self):
  980.         if not self.classifiers:
  981.             pass
  982.         return []
  983.  
  984.     
  985.     def get_download_url(self):
  986.         if not self.download_url:
  987.             pass
  988.         return 'UNKNOWN'
  989.  
  990.  
  991.  
  992. def fix_help_options(options):
  993.     """Convert a 4-tuple 'help_options' list as found in various command
  994.     classes to the 3-tuple form required by FancyGetopt.
  995.     """
  996.     new_options = []
  997.     for help_tuple in options:
  998.         new_options.append(help_tuple[0:3])
  999.     
  1000.     return new_options
  1001.  
  1002. if __name__ == '__main__':
  1003.     dist = Distribution()
  1004.     print 'ok'
  1005.  
  1006.